עקרונות שפות תכנות, סמסטר ב' 2016 תרגול 7: הסקת טיפוסים סטטית. Axiomatic Type Inference

Transcription

1 עקרונות שפות תכנות, סמסטר ב' 2016 תרגול 7: הסקת טיפוסים סטטית 1. Axiomatic type inference 2. Type inference using type constraints נושאי התרגול: Axiomatic Type Inference Definition (seen in class): A Type-substitution is a mapping, s, from a finite set of type-variables to a finite set of type-expressions, such that for every type-variable T, s(t) does not include T. A type-binding is a pair <T,s(T)> such that T = s(t). Type-s are written using set notation, for example: {T1 = Number, T2 = [Number -> T3]} {T1 = Number, T2 = [[Number -> T3]->T2]}, is this legal? Question 1 A typing statement is a true/false formula that states a judgment about the type of a language expression, given a type environment. It has the notation: Tenv - e:t, which reads: under the type-environment Tenv, the expression e has type T. E.g., {x:number} - (+ 3 x):number states that under the assumption that the type of x is Number, the type of (+ 3 x) is Number. For the typing statement below, note whether they are true or false: Typing statement true/false? {f:[number->t1]} - (f 7): T1 {y:number, f:[t1->t1]} - (f x):t1 {x:number} - x: Boolean {x:boolean, y:number} - x: Boolean Question 2 A typing-statement is based on assumptions in a given type-environment. The less assumptions are involved, the stronger is the statement. In order to end up with the strongest statement, we follow a simple heuristic rule: always pick a minimal type environment (or: always infer the strongest statement possible). For each pair of statements below, which statement is stronger? -1-

2 {foo: [T1->T2]} - 5:N {} - 5:N {x:n} - (+ x 3):N {y:n,x:n} - (+ x 3):N {} - (lambda (x)(+ x 3)):[N->N] {y:n} - (lambda (x)(+ x y)):[n->n] Note: A typing statement has to be true in order to determine its strength. Definitions (seen in class): An application of a type-substitution s to a type-expression TE, denoted by TE s, is a consistent replacement of type-variables T in TE by their mapped type-expressions s(t). For example: Well-typeness (partial definition): [[T1->T2]->T2] {T1=Boolean, T2=[T3->T3]} = [[Boolean->[T3->T3]] -> [T3->T3]] An expression, e, is well typed if Type-derivation(e) does not fail, i.e: Type-derivation(e)= TS, derivation, where Type-derivation is the set of typing statements obtained during the type inference for e. e has type t if it is well typed, and Type-derivation(e)= { } - e:t,derivation. Instantiation of typing statements: An instance of a typing statements TS is a typing statement TS that results from the application of a type-substitution s to all type expressions in TS. The instantiation is denoted by TS = TS s. Question 3 A unifier of type expressions TE1, TE2 is a type substitution s such that TE1 s = TE2 s (the type expressions should not include common type variables). The most general unifier (MGU), is a unifier such that any other unifier is an instance of it. All other unifiers are obtained from it by application of additional substitutions. Find the MGU for the following pairs of type-environments: s {x: T1}, {x: N} {x: T1, y: [T1->T2]}, {x: Number, y: [T3->T4]} {x: T1, y: [T1 -> T2]}, {x: [T3->T4], y: [T5->Number]} {x: T1, y: [T1->T2]}, {x: Number, y: [Symbol -> T3]} MGU {T1=N} (a non-mgu unifier: {T1=N, T2=B}) {T1=Number, T3=Number, T4=T2} {T1=[T3->T4], T5=[T3->T4], T2=Number} No unifier -2-

3 Question 4 Derive the type of the following expression: (lambda (x) (+ 7 x)) Step 1 Renaming: (lambda (x1) (+ 7 x1)) Step 2 Initializing derived-ts-pool: derived-ts-pool = { } Step 3 - Typing leaf expressions: The leaves are +, 7, x1. Instantiating the Number, Variable and the Primitive procedure axioms: (lambda (x1) (+ 7 x1)) (+ 7 x1) + 7 x1 a. Typing the expression 7: Typing axiom Number: For every type environment _Tenv and number _n: _Tenv - _n: Number Replacing the meta-variables _Tenv and _n with { } and 7, respectively, yields: (1) { } - 7 : Number derived-ts-pool= { (1) } b. Typing the expression + : Typing axiom Primitive +: For every type environment _Tenv: _Tenv - +:[N* *N-> N] Replacing the meta-variable _Tenv with { } yields: (2) { } - + : [N * * N -> N] derived-ts-pool = {(1), (2)} c. Typing the expression x1: Typing axiom Variable: For every type environment _Tenv and variable _v: _Tenv - _v: _Tenv(_v) Replacing _Tenv with {x1:t} and _v with the expression-variable x1, yields: (3) {x1:t} - x1:t derived-ts-pool = {(1), (2), (3)} Note: the Variable axiom uses a type-environment with an assumption to the typed variable. Since no type is declared for x, its type is just a type variable. Step 4 - Typing non-leaf expressions: a. Typing the expression (+ 7 x1): Typing Rule Application: For every: type environment _Tenv, expressions _f, _e1, _en, n>=0, and type expressions _S1,, _Sn, _S: If _Tenv - _f:[_s1* * _Sn -> _S], _Tenv - _e1:_s1,, _Tenv - _en:_sn Then _Tenv - (_f _e1 _en):_s -3-

4 Replacing _f, _e1 and _e2 with +, 7 and x1, respectively, yields an instance of that rule: For every: type environment _Tenv, expressions +, 7, x1, and type expressions _S1,_S2, _S: If _Tenv - +:[_S1*_S2 -> _S], _Tenv - 7:_S1, _Tenv - x1:_s2 Then _Tenv - (+ 7 x1):_s It remains to find _Tenv and a type-substitution, s, so that the condition of the rule holds. In other words, we seek for _Tenv and s such that: (_Tenv - +:[_S1*_S2 -> _S]) s derived-ts-pool s, (_Tenv - 7:_S1) s derived-ts-pool s, (_Tenv - x1:_s2) s derived-ts-pool s, where derived-ts-pool = { (1) { } - 7:N, (2) { } - +:[N * N -> N], (3) {x1:t} - x1:t } with _Tenv = {}, s = (_S1 = N, _S2 = N, _S = N) we get ({} - +:[_S1*_S2 -> _S]) s = (2) with _Tenv = {}, s = (_S1 = N) we get ({} - 7:_S1) s = (1) with _Tenv = {x1:t}, s = (_S2 = T), we get ({x1:t} - x1:_s2) s = (3) The problem: the condition of the rule uses the same _Tenv in all statements. We solve this by applying the Monotonicity rule to (1) and (2) with _Tenv ={x:t} and adding to derived-ts-pool: (1 ) {x1:t} - 7:N (2 ) {x1:t} - +:N * N -> N The instance of the rule now becomes: For every: type environment {x1:t}, expressions +, 7, x1, and type expressions _S1,_S2, _S: If {x1:t} - +:[_S1*_S2 -> _S], {x1:t} - 7:_S1, {x1:t} - x1:_s2 Then {x1:t} - (+ 7 x1):_s With type-substitution s = (_S1 = N, _S2 = N, _S = N, T = _S2}, the condition holds and the result is the conclusion of the rule: (4) {x:n} - (+ x 7): N derived-ts-pool={(1) (1 ) (2) (2 ) (3) (4)} -4-

5 b. Typing the expression (lambda (x1) (+ 7 x1)) : Typing rule Procedure: For every: type environment Tenv variables _x1,..., _xn, n >= 0 expressions _b1,..., _bm, m >= 1, and type expressions _S1,...,_Sn, _U1,...,_Um : If _Tenv {_x1:_s1,...,_xn:_sn } - _bi:_ui for all i=1 m Then _Tenv - (lambda (_x1... _x_n ) _b1... _bm) : [_S1*...*_Sn -> _Um] Replacing _Tenv with { }, _x1 with x1 and _b1 with (+ 7 x1), yields an instance of that rule: For every: type environment {} variables x1 expressions (+ 7 x1), and type expressions _S1, _U1: If { } {x1:_s1} - (+ 7 x1):_u1 Then { } - (lambda (x1) (+ 7 x1)) : [_S1 -> _Um] Now, with type-substitution s = (_S1 = N, _U1 = N), the condition of the rule holds and the result is the conclusion of the rule: (5) { } -(lambda(x1) (+ x1 7)): [N -> N] derived-ts-pool = {(1) (1 ) (2) (2 ) (3) (4) (5)} Finally, the output of the algorithm is: {{ } -(lambda(x) (+ x 7)): [N->N], derived-ts-pool}. By the definition, (lambda(x) (+ 7 x)) is well typed and its type is [N->N]. Question 5: Derive the type for the following expression: (lambda (x) (+ y (- x 1))) Step 1 Renaming: (lambda (x1) (+ y1 (- x1 1))) Step 2 Initializing derived-ts-pool: derived-ts-pool = { } Step 3 - Typing leaf expressions: The leaves are +, y, -, x1, 1. Instantiating the Number, Variable and the Primitive procedure axioms, yields: (1) { } - +: [N * N -> N] (2) {y1: T1} - y1: T1 (3) { } - -: [N * N -> N] (4) {x1: T2} - x1: T2 (5) { } - 1: N pool = {(1), (2), (3), (4), (5)} (lambda (x1)(+ y1 (- x1 1))) (+ y (- x1 1)) + y (- x1 1) - x1 1-5-

6 Step 4 - Typing non-leaf expressions: a. Typing the expression (- x1 1): In typing rule Application, replacing _f, _e1 and _e2 for -, x1 and 1, respectively, yields: For every: type environment _Tenv, expressions -, x1, 1, and type expressions _S1,_S2, _S: If _Tenv - -:[_S1*_S2 -> _S], _Tenv - x1:_s1, _Tenv - 1:_S2 Then _Tenv - (- x1 1):_S Using the monotonicity rule, we add the following statements to derived-ts-pool: (3 ) {x1:t2} - -: [N * N -> N] (5 ) {x1:t2} - 1: N With _Tenv={x1:T2} and type-substitution s = (_S1 = N, _S2 = N, _S = N, T2=_S2) the condition of the rule holds and the result is the conclusion of the rule: (6) {x1: N} - (- x1 1) : N pool = {(1) (2) (3) (4) (5) (3 ) (5 ) (6)} b. Typing the expression (+ y (- x1 1)): In typing rule Application, replacing _f, _e1 and _e2 for +, y and (- x1 1), respectively, yields: For every: type environment Tenv, expressions +, y, (- x1 1), and type expressions _S1,_S2, _S: If _Tenv - +:[_S1*_S2 -> _S], _Tenv - y:_s1, _Tenv - (- x1 1):_S2 Then _Tenv - (+ y (- x1 1)):_S Using the monotonicity rule, we add the following statements to derived-ts-pool: (1 ) {y: T1, x1: T2} - +: N * N -> N (6 ) {y: T1, x1: T2} - (- x1 1):N (2 ) {y: T1, x1: T2} - y: N Now, with type-substitution s = (_S1 = N, _S2 = N, _S = N, T1 = _S1, T2=_S2), the condition of the rule holds and the result is the conclusion: (7) {y: N, x1: N} - (+ y (- x1 1)): N pool = {(1) (1 ) (2) (2 ) (3) (3 ) (4) (5) (5 ) (6) (6 ) (7)} -6-

7 c. Typing the expression (lambda(x1) (+ y (- x1 1))) : In typing rule Procedure, replacing _Tenv with {y:n}, _x1 with x1 and _b1 with (+ y (- x1 1)) yields: For every: type environment {y:n}, variable x1, expression (+ y (- x1 1)), type expressions _S1, _U1: If {y:n} {x1:_s1} - (+ y (- x1 1)):_U1 Then {y:n} -(lambda(x1)(+ y (- x1 1))):[_S1 -> _U1] With type substitution s = (_S1 = N, _U1 = N), the condition holds and the conclusion is: (8) {y: N} -(lambda (x1)(+ y (- x 1)):[N -> N] pool = {(1) (1 ) (2) (2 ) (3) (3 ) (4) (5) (5 ) (6) (6 ) (7) (8)} Output: {{y: N} -(lambda (x1)(+ y (- x 1)):[N -> N], pool}. Note: The type environment, {y: Number}, in the output statement is not empty. From the definition of well-typeness, the expression is well typed. However, we cannot associate a type with the expression. Question: Could we associate a type with the expression if we added expression (define y 5) before it? Question 6 (optional): Derive the type of the expression (define foo (lambda (x) (foo (+ x 1)))) Step 1 Renaming: (define foo (lambda (x1) (foo (+ x1 1)))) Step 2 Initializing derived-ts-pool: pool = { } Step 3 - Typing leaf expressions: The leaves are +, foo, x1, 1. Instantiating the Number, Variable and the Primitive procedure axioms, yields: (1) {} - 1: Number (2) {} - +: [N * N -> N] (3) {x1:t1} - x1: T1 (4) {foo:t2} - foo: T2 pool = {(1), (2), (3), (4)} Step 4 - Typing non-leaf expressions We skip a few steps forward to evaluate the type for (lambda (x1) (foo (+ x1 1))), where pool = { (1) {} - 1: N, (1') {x1: N} - 1: N, (2) {} - +: [N * N -> N], (2') {x1: N} - +: [N * N -> N], -7-

8 (3) {x1: T1} - x1: T1, (4) {foo: T2} - foo: T2, (5) {x1: N} - (+ x1 1): N, (6) {x1: N, foo: [N -> T3]} - foo: [N -> T3], (5') {x1: N, foo: [N -> T3]} - (+ x1 1): N, (7) {x1: N, foo: [N -> T3]} - (foo (+ x1 1)): T3} a. Typing the expression (lambda (x1) (foo (+ x1 1))): In typing rule Procedure, replacing _Tenv with {foo: [N -> T3]}, _x1 with x1 and _b1 with (foo (+ x1 1)), yields: For every: type environment {foo: [N -> T3]}, variables x1 expressions (foo (+ x1 1)), and type expressions _S1, _U1: If {foo: [N -> T3]} {x1:_s1} - (foo (+ x1 1)): _U1 Then {foo: [N -> T3]} - (lambda(x1) (foo (+ x1 1))):[_S1-> _U1] With type substitution s = (_S1 = N, _U1 = T3), the condition holds, and the results is: (8) {foo: [N ->T3]} - (lambda(x1)(foo (+ x1 1))): [N -> T3] pool = {(1),, (7) (8)} b. Typing the expression (define foo (lambda (x) (foo (+ x 1)))): In typing rule Recursive-definition, replacing _f with foo and _e with (lambda (x) (foo (+ x 1))) yields: For every: recursive-definition expression (define foo (lambda (x) (foo (+ x 1)))) and type expression _S: If { foo:_s } - (lambda (x) (foo (+ x 1))):_S, Then { } - (define foo (lambda (x) (foo (+ x 1)))):Void, and { } - foo:_s Restriction: No repeated variable definitions. With type substitution s = (_S = [Number->T3]), the condition holds and the result is: (9) { } - (define foo (lambda (x)(foo (+ x 1)))):Void, and (10) { } - foo: [Number -> T3] pool = {(1),..., (7), (8), (9), (10)} Output: {(9), pool}. The expression well typed and has type void. Question 7 (optional) When we derive the expression: ( (lambda (f) (+ (f 'a) (f 5))) (lambda (x) 3) ), the axiomatic type inference process fails for the expression (+ (f 'a) (f 5)). However, Racket evaluates the expression with no troubles. How is that possible? -8-

9 Type inference using type constraints 1. Rename bound variables. 2. Assign type variables to all sub-expressions. 3. Construct type equations. 4. Solve the equations. Question 1 Typing the expression ((lambda (f x) (f x)) sqrt 4): Stage I: Rename bound variables. No other reference of variables f and x so no renaming is needed. Stage II: Assign type variables for every sub expression: Variable ((lambda (f x) (f x)) sqrt 4) T0 (lambda (f x) (f x)) T1 (f x) T2 f Tf x Tx sqrt Tsqrt 4 Tnum4 Stage III: Construct type equations. The equations for the sub-expressions are: ((lambda (f x) (f x)) sqrt 4) T1 = [Tsqrt * Tnum4 -> T0] (lambda (f x) (f x)) T1 = [Tf * Tx -> T2] (f x) Tf = [Tx -> T2] The equations for the primitives are: sqrt Tsqrt = [Number -> Number] 4 Tnum4 = Number Stage IV: Solve the equations. 1. T1 = [Tsqrt * Tnum4 -> T0] {} 2. T1 = [Tf * Tx -> T2] 3. Tf = [Tx -> T2] 4. Tsqrt = [Number -> Number] 5. Tnum4 = Number -9-

10 Step 1: (T1 = [Tsqrt * Tnum4-> T0]) = (T1 = [Tsqrt * Tnum4-> T0]) and is a type-sub. = (T1 = [Tsqrt * Tnum4-> T0]). 2. T1 = [Tf * Tx -> T2] {T1 := [Tsqrt * Tnum4 -> T0]} 3. Tf = [Tx -> T2] 4. Tsqrt = [Number -> Number] 5. Tnum4 = Number Step 2: T1 = [Tf * Tx -> T2] = ([Tsqrt * Tnum4 -> T0] = [Tf * Tx -> T2]), not typesub. Because both sides of the equation are composite we split it into three equations and remove equation Tf = [Tx -> T2] {T1 := [Tsqrt * Tnum4 -> T0]} 4. Tsqrt = [Number -> Number] 5. Tnum4 = Number 6. Tf = Tsqrt 7. Tx = Tnum4 (or Tnum4 = Tx) Step 3: (Tf = [Tx -> T2]) = (Tf = [Tx -> T2]). = (Tf = [Tx -> T2]). 4. Tsqrt = [Number -> Number] {T1 := [Tsqrt * Tnum4 -> T0] 5. Tnum4 = Number Tf := [Tx -> T2]} 6. Tf = Tsqrt 7. Tx = Tnum4 Step 4: (Tsqrt = [Number -> Number]) = (Tsqrt = [Number -> Number]). = (Tsqrt = [Number -> Number]). 5. Tnum4 = Number {T1 := [[Number -> Number] * Tnum4-> T0] 6. Tf = Tsqrt Tf := [Tx -> T2] 7. Tx = Tnum4 Tsqrt := [Number -> Number]} -10-

11 Step 5: (Tnum4 =Number) = (Tnum4 =Number), is a type-sub. = (Tnum4 =Number). 6. Tf = Tsqrt {T1 := [[Number -> Number]* Number -> T0] 7. Tx = Tnum4 Tf := [Tx -> T2] Tsqrt := [Number -> Number] Tnum4 := Number} Step 6: (Tf = Tsqrt) = ([Tx -> T2]=[Number -> Number]), not a sub-type. We split the equation into two equations Tx = Number and T2 = Number and remove equation Tx = Tnum4 {T1 := [[Number -> Number]* Number -> T0] 9. Tx = Number Tf := [Tx -> T2] Tsqrt := [Number -> Number] 10. T2 = Number Tnum4 := Number} Step 7: (Tx = Tnum4) = ([Tx -> Number]), type-sub. = ([Tx -> Number]). {T1 := [[Number -> Number] * Number -> T0] 9. Tx = Number Tf := [Number -> T2] 10. T2 = Number Tsqrt := [Number -> Number] Tnum4 := Number Tx := Number} Step 8: (T2 = T0) = (T2 = T0), type-sub. = (T2 = T0). 9. Tx = Number {T1 := [[Number -> Number] * Number -> T0] 10. T2 = Number Tf := [Number -> T0] Tsqrt := [Number -> Number] Tnum4 := Number Tx := Number T2 := T0} -11-

12 Step 9: (Tx = Number) = (Number = Number) always true. Step 10: 10. T2 = Number {T1 := [[Number -> Number] * Number -> T0] Tf := [Number -> T0] Tsqrt := [Number -> Number] Tnum4 := Number Tx := Number T2 := T0} (T2 = Number) = (T0 = Number), type-sub. = (T0 = Number). {T1 := [[Number -> Number] * Number -> Number] Tf := [Number -> Number] Tsqrt := [Number -> Number] Tnum4 := Number Tx := Number T2 := Number T0 = Number} The type inference succeeds, meaning that the expression is well typed. Because there are no free variables, the inferred type of T0 is: Number. -12-

13 Question 2: Extending the typing mechanism for if expressions: Recall the typing rule for if expressions shown in the axiomatic typing system: Typing rule If : For every: type environment _Tenv, expressions _e1, _e2, _e3, and type expressions _S1, _S2: If _Tenv - _e1:_s1, _Tenv - _e2:_s2, _Tenv - _e3:_s2 Then _Tenv - (if _e1 _e2 _e3):_s2 First thing we notice from the rule is that the consequence expression (_c) and the alternative expression (_a) have the same type. Given the first observation, the second thing we notice is that the type of the if expression is the type of the consequence expression. Given the two observation we can add the following equations: (if _p _c _a) T_c = T_a Tif = T_c Questions: 1) If both consequence and alternative expressions had different types could we type the if expression? 2) Do we need to add an equation for _p? Example: type the expression (if #t (+ 1 2) 3) Stage I: Rename bound variables: No reference of variables so no renaming is needed. Stage II: Assign type variables for every sub expression: Variable (if #t (+ 1 2) 3) T0 (+ 1 2) T1 + T+ #t T#t 1 Tnum1 2 Tnum2 3 Tnum3 Stage III: Construct type equations. The equations for the sub-expressions are: (if #t (+ 1 2) 3) T1 = Tnum3 T0 = T1 (+ 1 2) T+ = [Tnum1 * Tnum2 -> T1] -13-

14 The equations for the primitives are: + T+ = [Number * Number -> Number] #t T#t = Boolean 1 Tnum1 = Number 2 Tnum2 = Number 3 Tnum3 = Number Stage IV: Solve the equations: 1. T1 = Tnum3 {} 2. T0 = T1 3. T+ = [Tnum1 * Tnum2 -> T1] 4. T+ = [Number * Number -> Number] 5. T#t = Boolean 6. Tnum1 = Number 7. Tnum2 = Number 8. Tnum3 = Number Step 1: (T1 = Tnum3) = (T1 = Tnum3), type-sub. = (T1 = Tnum3). 2. T0 = T1 { T1 := Tnum3 } 3. T+ = [Tnum1 * Tnum2 -> T1] 4. T+ = [Number * Number -> Number] 5. T#t = Boolean 6. Tnum1 = Number 7. Tnum2 = Number 8. Tnum3 = Number Step 2: (T0 = T1) = (T0 = Tnum3), type-sub. = (T0 = Tnum3). 3. T+ = [Tnum1 * Tnum2 -> T1] { T1 := Tnum3, 4. T+ = [Number * Number -> Number] T0 := Tnum3 } 5. T#t = Boolean 6. Tnum1 = Number 7. Tnum2 = Number 8. Tnum3 = Number -14-

15 Step 3: (T+ = [Tnum1 * Tnum2 -> T1]) = (T+ = [Tnum1 * Tnum2 -> Tnum3]), type-sub. = (T+ = [Tnum1 * Tnum2 -> Tnum3]). 4. T+ = [Number * Number -> Number] { T1 := Tnum3, 5. T#t = Boolean T0 := Tnum3, 6. Tnum1 = Number T+ := [Tnum1 * Tnum2 -> Tnum3]} 7. Tnum2 = Number 8. Tnum3 = Number Step 4: (T+ = [Number * Number -> Number]) = ([Tnum1 * Tnum2 -> Tnum3] = [Number * Number -> Number]), not a type-sub. We split the equation to Tnum1 = Number, Tnum2 = Number and Tnum3 = Number, and add them to the equations. Since they already exists, we only need to remove equation T#t = Boolean { T1 := Tnum3, 6. Tnum1 = Number T0 := Tnum3, 7. Tnum2 = Number T+ := [Tnum1 * Tnum2 -> Tnum3]} 8. Tnum3 = Number Skipping the trivial steps, we get: { T1 := Number, T0 := Number, T#t := Boolean, Tnum1 := Number, Tnum2 := Number, Tnum3 := Number, T+ := [Number * Number -> Number]} The type inference succeeds, meaning that the expression is well typed. Because there are no free variables, the inferred type of T0 is: Number. -15-

16 Question 3 (optional) Typing the application ((lambda (f x) (f x)) 4 sqrt): Stage I: Rename bound variables. No other reference of variables f and x so no renaming is needed. Stage II: Assign type variables for every sub expression and primitives: Variable ((lambda (f x) (f x)) 4 sqrt) T0 (lambda (f x) (f x)) T1 (f x) T2 f Tf x Tx 4 Tnum4 sqrt Tsqrt Stage III: Construct type equations. The equations for the sub-expressions are: ((lambda(f x) (f x)) 4 sqrt) T1 = [Tnum4 * Tsqrt -> T0] (lambda(f x) (f x)) T1 = [Tf * Tx -> T2] (f x) Tf = [Tx -> T2] The equations for the primitives are: 4 Tnum4 = Number sqrt Tsqrt = [Number -> Number] Stage IV: Solve the equations. 1. T1 = [Tnum4 * Tsqrt -> T0] {} 2. T1 = [Tf * Tx -> T2] 3. Tf = [Tx -> T2] 4. Tnum4 = Number 5. Tsqrt = [Number -> Number] Step 1: (T1 = [Tnum4 * Tsqrt -> T0]) = (T1 = [Tnum4 * Tsqrt -> T0]), type-sub. = (T1 = [Tnum4 * Tsqrt -> T0]). 2. T1 = [Tf * Tx -> T2] {T1 := [Tnum4 * Tsqrt -> T0]} 3. Tf = [Tx -> T2] 4. Tnum4 = Number 5. Tsqrt = [Number -> Number] -16-

17 Step 2: (T1 = [Tf * Tx -> T2]) = ([Tf * Tx -> T2] = [Tnum4 * Tsqrt -> T0]), not a type-sub. We split the equation to Tf = Tnum4, Tx = Tsqrt, T2 = T0, add them to the equations and remove equation Tf = [Tx -> T2] {T1 := [Tnum4 * Tsqrt -> T0]} 4. Tnum4 = Number 5. Tsqrt = [Number -> Number] 6. Tf = Tnum4 7. Tx = Tsqrt Step 3: (Tf = [Tx -> T2]) = (Tf = [Tx -> T2]), type-sub. = (Tf = [Tx -> T2]). 4. Tnum4 = Number {T1 := [Tnum4 * Tsqrt -> T0] 5. Tsqrt = [Number -> Number] Tf = [Tx -> T2]} 6. Tf = Tnum4 7. Tx = Tsqrt Step 4: (Tnum4 = Number) = (Tnum4 = Number), type-sub. = (Tnum4 = Number). 5. Tsqrt = [Number -> Number] {T1 :=[Number * Tsqrt -> T0] 6. Tf = Tnum4 Tf = [Tx -> T2] 7. Tx = Tsqrt Tnum4 = Number} Step 5: (Tsqrt = [Number -> Number]) = (Tsqrt = [Number -> Number]), type-sub. = (Tsqrt = [Number -> Number]). 6. Tf = Tnum4 {T1 :=[Number * [Number- > Number] -> T0] 7. Tx = Tsqrt Tf := [Tx -> T2] Tnum4 := Number Tsqrt := [Number->Number]} Step 6: (Tf = Tnum4) = ([Tx -> T2] = Number), We get the conflicting equation [Tx -> T2] = Number and we can say that the expression is not well typed. -17-